home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / c / cxref-1.001 / cxref-1~ / cxref / query / input.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-24  |  11.8 KB  |  415 lines
  1. /***************************************
  2.   $Header: /home/amb/cxref/query/RCS/input.c 1.3 1996/02/24 14:53:44 amb Exp $
  3.  
  4.   C Cross Referencing & Documentation tool. Version 1.0
  5.   ******************/ /******************
  6.   Written by Andrew M. Bishop
  7.  
  8.   This file Copyright 1995,96 Andrew M. Bishop
  9.   It may be distributed under the GNU Public License, version 2, or
  10.   any higher version.  See section COPYING of the GNU Public license
  11.   for conditions under which this file may be redistributed.
  12.   ***************************************/
  13.  
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17.  
  18. #include "../memory.h"
  19. #include "../datatype.h"
  20. #include "../cxref.h"
  21. #include "query.h"
  22.  
  23. /*+ The names of the function cross reference files. +*/
  24. #define XREF_FUNC_FILE   ".function"
  25.  
  26. /*+ The names of the variable cross reference files. +*/
  27. #define XREF_VAR_FILE    ".variable"
  28.  
  29. /*+ The names of the include cross reference files. +*/
  30. #define XREF_INC_FILE    ".include"
  31.  
  32. /*+ The names of the type cross reference files. +*/
  33. #define XREF_TYPE_FILE   ".typedef"
  34.  
  35. /*+ The command line switch that sets the amount of cross referencing to do. +*/
  36. extern int option_xref;
  37.  
  38. /*+ The command line switch for the output name, +*/
  39. extern char *option_odir,       /*+ The directory to use. +*/
  40.             *option_name;       /*+ The base part of the name. +*/
  41.  
  42. extern File *files;             /*+ The files that are queried. +*/
  43. extern int n_files;             /*+ The number of files referenced. +*/
  44.  
  45. extern Function *functions;     /*+ The functions that are queried. +*/
  46. extern int n_functions;         /*+ The number of functions referenced. +*/
  47.  
  48. extern Variable *variables;     /*+ The variables that are queried. +*/
  49. extern int n_variables;         /*+ The number of variables referenced. +*/
  50.  
  51. extern Typedef *typedefs;       /*+ The type definitions that are queried. +*/
  52. extern int n_typedefs;          /*+ The number of typedefs referenced. +*/
  53.  
  54. /* Local functions */
  55.  
  56. static void cross_reference_functions(void);
  57. static void cross_reference_variables(void);
  58.  
  59. /*++++++++++++++++++++++++++++++++++++++
  60.   Read in all the information from the cross reference files.
  61.   ++++++++++++++++++++++++++++++++++++++*/
  62.  
  63. void LoadInCrossRefs(void)
  64. {
  65.  FILE *in;
  66.  char *ifile;
  67.  
  68.  /* Format: filename [[%]include1] [[%]include2] ... : Files include1, include2, ... are included in filename;
  69.     those with a % are local. */
  70.  
  71.  /* First do the files */
  72.    {
  73.     char include[128],filename[128],ch;
  74.     int i;
  75.  
  76.     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_INC_FILE);
  77.  
  78.     in =fopen(ifile,"r");
  79.  
  80.     if(!in)
  81.       {fprintf(stderr,"cxref-query: Failed to open the include cross reference file '%s'\n",ifile);exit(1);}
  82.  
  83.     while(fscanf(in,"%s%c",filename,&ch)==2)
  84.       {
  85.        if(n_files)
  86.           files=(File*)Realloc(files,(n_files+1)*sizeof(File*));
  87.        else
  88.           files=(File*)Malloc(sizeof(File*));
  89.  
  90.        files[n_files]=(File)Calloc(1,sizeof(struct _File));
  91.        files[n_files]->name=MallocString(filename);
  92.  
  93.        while(ch==' ')
  94.          {
  95.           Include inc=(Include)Calloc(1,sizeof(struct _Include));
  96.  
  97.           fscanf(in,"%s%c",include,&ch);
  98.  
  99.           if(include[0]=='%')
  100.              {inc->scope=LOCAL;
  101.               inc->name=MallocString(&include[1]);}
  102.           else
  103.              {inc->scope=GLOBAL;
  104.               inc->name=MallocString(include);}
  105.  
  106.           AddToLinkedList(files[n_files]->includes,Include,inc);
  107.          }
  108.        n_files++;
  109.       }
  110.  
  111.     fclose(in);
  112.  
  113.     for(i=0;i<n_files;i++)
  114.       {
  115.        int j;
  116.        Include inc=files[i]->includes;
  117.  
  118.        while(inc)
  119.          {
  120.           for(j=0;j<n_files;j++)
  121.              if(!strcmp(inc->name,files[j]->name))
  122.                 inc->includes=files[j]->includes;
  123.           inc=inc->next;
  124.          }
  125.       }
  126.    }
  127.  
  128.  /* Format: filename funcname scope [[%][&]funcname1] [[%][&]funcname2] ... : The function funcname in file filename
  129.     calls or references functions funcname1, funcname2 ... ; those with a % are local, with a & are references. */
  130.  /* Format: filename $ 0 [[%]&funcname1] [[%]&funcname2] ... : The file references functions funcname1, funcname2 ... ;
  131.     those with a % are local.  */
  132.  
  133.  /* Now do the functions */
  134.    {
  135.     char ch,funcname[64],filename[128],called[64];
  136.     int scope;
  137.  
  138.     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_FUNC_FILE);
  139.  
  140.     in =fopen(ifile,"r");
  141.  
  142.     if(!in)
  143.       {fprintf(stderr,"cxref-query: Failed to open the functional cross reference file '%s'\n",ifile);exit(1);}
  144.  
  145.     while(fscanf(in,"%s %s %d%c",filename,funcname,&scope,&ch)==4)
  146.       {
  147.        int i;
  148.        StringList *f_refs;
  149.  
  150.        for(i=0;i<n_files;i++)
  151.           if(!strcmp(files[i]->name,filename))
  152.              break;
  153.  
  154.        if(funcname[0]=='$')
  155.           f_refs=&files[i]->f_refs;
  156.        else
  157.          {
  158.           if(n_functions)
  159.              functions=(Function*)Realloc(functions,(n_functions+1)*sizeof(Function*));
  160.           else
  161.              functions=(Function*)Malloc(sizeof(Function*));
  162.  
  163.           functions[n_functions]=(Function)Calloc(1,sizeof(struct _Function));
  164.  
  165.           AddToLinkedList(files[i]->functions,Function,functions[n_functions]);
  166.  
  167.           functions[n_functions]->comment=MallocString(filename); /* Use comment field for filename */
  168.           functions[n_functions]->name=MallocString(funcname);
  169.           functions[n_functions]->scope=scope;
  170.  
  171.           f_refs=&functions[n_functions]->f_refs;
  172.          }
  173.  
  174.        while(ch==' ')
  175.          {
  176.           char* c;
  177.           fscanf(in,"%s%c",called,&ch);
  178.  
  179.           c=called;
  180.           if(c[0]=='%') c++;
  181.           if(c[0]=='&')
  182.             {
  183.              if(c==called)
  184.                 AddToStringList(f_refs,c+1,1);
  185.              else
  186.                 AddToStringList(f_refs,ConcatStrings(3,c+1," : ",filename),1);
  187.             }
  188.           else
  189.             {
  190.              if(c==called)
  191.                 AddToStringList(&functions[n_functions]->calls,c,1);
  192.              else
  193.                 AddToStringList(&functions[n_functions]->calls,ConcatStrings(3,c," : ",filename),1);
  194.             }
  195.          }
  196.        n_functions++;
  197.       }
  198.  
  199.     cross_reference_functions();
  200.  
  201.     fclose(in);
  202.    }
  203.  
  204.  /* Format: filename varname scope [$] [[%]funcname1] [[%]funcname2] ... : variable varname is used in
  205.     the file filename if $, and functions funcname1, funcname2 ... Those with a % are local.  */
  206.  
  207.  /* Now do the variables */
  208.    {
  209.     char varname[64],filename[128],funcname[64],ch;
  210.     int scope;
  211.  
  212.     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_VAR_FILE);
  213.  
  214.     in =fopen(ifile,"r");
  215.  
  216.     if(!in)
  217.       {fprintf(stderr,"cxref-query: Failed to open the variable cross reference file '%s'\n",ifile);exit(1);}
  218.  
  219.     while(fscanf(in,"%s %s %d%c",filename,varname,&scope,&ch)==4)
  220.       {
  221.        int i;
  222.  
  223.        for(i=0;i<n_files;i++)
  224.           if(!strcmp(files[i]->name,filename))
  225.              break;
  226.  
  227.        if(n_variables)
  228.           variables=(Variable*)Realloc(variables,(n_variables+1)*sizeof(Variable*));
  229.        else
  230.           variables=(Variable*)Malloc(sizeof(Variable*));
  231.  
  232.        variables[n_variables]=(Variable)Calloc(1,sizeof(struct _Variable));
  233.  
  234.        AddToLinkedList(files[i]->variables,Variable,variables[n_variables]);
  235.  
  236.        variables[n_variables]->comment=MallocString(filename); /* Use comment field for filename */
  237.        variables[n_variables]->name=MallocString(varname);
  238.        variables[n_variables]->scope=scope;
  239.  
  240.        while(ch==' ')
  241.          {
  242.           fscanf(in,"%s%c",funcname,&ch);
  243.  
  244.           if(funcname[0]=='$')
  245.              AddToStringList(&variables[n_variables]->used,ConcatStrings(2,"$",filename),1);
  246.           else
  247.              if(funcname[0]=='%')
  248.                 AddToStringList(&variables[n_variables]->used,ConcatStrings(3,&funcname[1]," : ",filename),1);
  249.              else
  250.                 AddToStringList(&variables[n_variables]->used,funcname,1);
  251.          }
  252.        n_variables++;
  253.       }
  254.  
  255.     cross_reference_variables();
  256.  
  257.     fclose(in);
  258.    }
  259.  
  260.  /* Format: filename typename type... : For a typedef type.     */
  261.  /* Format: filename #        type... : For a non typedef type. */
  262.  
  263.  /* Now do the types */
  264.    {
  265.     char typename[128],filename[128],typetype[128];
  266.  
  267.     ifile=ConcatStrings(4,option_odir,"/",option_name,XREF_TYPE_FILE);
  268.  
  269.     in =fopen(ifile,"r");
  270.  
  271.     if(!in)
  272.       {fprintf(stderr,"cxref-query: Failed to open the typedef reference file '%s'\n",ifile);exit(1);}
  273.  
  274.     while(fscanf(in,"%s %s",filename,typename)==2)
  275.       {
  276.        int i;
  277.  
  278.        fgets(typetype,128,in);
  279.  
  280.        for(i=0;i<n_files;i++)
  281.           if(!strcmp(files[i]->name,filename))
  282.              break;
  283.  
  284.        if(n_typedefs)
  285.           typedefs=(Typedef*)Realloc(typedefs,(n_typedefs+1)*sizeof(Typedef*));
  286.        else
  287.           typedefs=(Typedef*)Malloc(sizeof(Typedef*));
  288.  
  289.        typedefs[n_typedefs]=(Typedef)Calloc(1,sizeof(struct _Typedef));
  290.  
  291.        AddToLinkedList(files[i]->typedefs,Typedef,typedefs[n_typedefs]);
  292.  
  293.        if(typename[0]!='#')
  294.          {
  295.           typedefs[n_typedefs]->name=MallocString(typename);
  296.           typedefs[n_typedefs]->type=MallocString(&typetype[1]);
  297.          }
  298.        else
  299.          {
  300.           typedefs[n_typedefs]->name=MallocString(&typetype[1]);
  301.           typedefs[n_typedefs]->type=NULL;
  302.          }
  303.  
  304.        n_typedefs++;
  305.       }
  306.  
  307.     fclose(in);
  308.    }
  309.  
  310. }
  311.  
  312.  
  313. /*++++++++++++++++++++++++++++++++++++++
  314.   Performs all of the cross referencing between global functions and functions that they call.
  315.   ++++++++++++++++++++++++++++++++++++++*/
  316.  
  317. static void cross_reference_functions(void)
  318. {
  319.  int i1,j1,i2;
  320.  char* colon;
  321.  
  322.  for(i1=0;i1<n_functions;i1++)
  323.    {
  324.     Function func1=functions[i1];
  325.  
  326.     for(j1=0;j1<func1->calls.n;j1++)
  327.       {
  328.        if(!strchr(func1->calls.s[j1],':'))
  329.           for(i2=0;i2<n_functions;i2++)
  330.             {
  331.              Function func2=functions[i2];
  332.  
  333.              if(func2->scope&GLOBAL && !strcmp(func1->calls.s[j1],func2->name))
  334.                {
  335.                 char* old=func1->calls.s[j1];
  336.                 func1->calls.s[j1]=ConcatStrings(3,func1->calls.s[j1]," : ",func2->comment);
  337.                 Free(old);
  338.                 break;
  339.                }
  340.             }
  341.  
  342.        if((colon=strchr(func1->calls.s[j1],':')))
  343.          {
  344.           char* func=func1->calls.s[j1];
  345.           char* file=&colon[2];
  346.           colon[-1]=0;
  347.  
  348.           for(i2=0;i2<n_functions;i2++)
  349.             {
  350.              Function func2=functions[i2];
  351.  
  352.              if(!strcmp(func,func2->name) && !strcmp(file,func2->comment))
  353.                {
  354.                 AddToStringList(&func2->called,ConcatStrings(3,func1->name," : ",func1->comment),1);
  355.                 break;
  356.                }
  357.             }
  358.           colon[-1]=' ';
  359.          }
  360.       }
  361.    }
  362. }
  363.  
  364.  
  365. /*++++++++++++++++++++++++++++++++++++++
  366.   Performs all of the cross referencing between global variables and functions that use them.
  367.   ++++++++++++++++++++++++++++++++++++++*/
  368.  
  369. static void cross_reference_variables(void)
  370. {
  371.  int i1,j1,i2;
  372.  char* colon;
  373.  
  374.  for(i1=0;i1<n_variables;i1++)
  375.    {
  376.     Variable var1=variables[i1];
  377.  
  378.     for(j1=0;j1<var1->used.n;j1++)
  379.       {
  380.        if(var1->used.s[j1][0]!='$' && !strchr(var1->used.s[j1],':'))
  381.           for(i2=0;i2<n_functions;i2++)
  382.             {
  383.              Function func2=functions[i2];
  384.  
  385.              if(func2->scope&GLOBAL && !strcmp(var1->used.s[j1],func2->name))
  386.                {
  387.                 char* old=var1->used.s[j1];
  388.                 var1->used.s[j1]=ConcatStrings(3,var1->used.s[j1]," : ",func2->comment);
  389.                 Free(old);
  390.                 break;
  391.                }
  392.             }
  393.  
  394.        if((colon=strchr(var1->used.s[j1],':')))
  395.          {
  396.           char* func=var1->used.s[j1];
  397.           char* file=&colon[2];
  398.           colon[-1]=0;
  399.  
  400.           for(i2=0;i2<n_functions;i2++)
  401.             {
  402.              Function func2=functions[i2];
  403.  
  404.              if(!strcmp(func,func2->name) && !strcmp(file,func2->comment))
  405.                {
  406.                 AddToStringList(&func2->v_refs,ConcatStrings(3,var1->name," : ",var1->comment),1);
  407.                 break;
  408.                }
  409.             }
  410.           colon[-1]=' ';
  411.          }
  412.       }
  413.    }
  414. }
  415.